package com.bieyang.anjia.net;

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import java.util.Locale;
import java.util.concurrent.ConcurrentHashMap;

 

import org.apache.http.client.CookieStore;
import org.apache.http.cookie.Cookie;

import android.content.Context;
import android.content.SharedPreferences;
import android.text.TextUtils;
import android.util.Log;

public class PersistentCookieStore  implements CookieStore {

	 private static final String LOG_TAG = "PersistentCookieStore";  
	    private static final String COOKIE_PREFS = "CookiePrefsFile";  
	    private static final String COOKIE_NAME_STORE = "names";  
	    private static final String COOKIE_NAME_PREFIX = "cookie_";  
	    private boolean omitNonPersistentCookies = false;  
	  
	    private final ConcurrentHashMap<String, Cookie> cookies;  
	    private final SharedPreferences cookiePrefs;  
	  
	    /** 
	     * Construct a persistent cookie store. 
	     * 
	     * @param context Context to attach cookie store to 
	     */  
	    public PersistentCookieStore(Context context) {  
	        cookiePrefs = context.getSharedPreferences(COOKIE_PREFS, 0);  
	        cookies = new ConcurrentHashMap<String, Cookie>();  
	  
	        // Load any previously stored cookies into the store  
	        String storedCookieNames = cookiePrefs.getString(COOKIE_NAME_STORE, null);  
	        if (storedCookieNames != null) {  
	            String[] cookieNames = TextUtils.split(storedCookieNames, ",");  
	            for (String name : cookieNames) {  
	                String encodedCookie = cookiePrefs.getString(COOKIE_NAME_PREFIX + name, null);  
	                if (encodedCookie != null) {  
	                    Cookie decodedCookie = decodeCookie(encodedCookie);  
	                    if (decodedCookie != null) {  
	                        cookies.put(name, decodedCookie);  
	                    }  
	                }  
	            }  
	  
	            // Clear out expired cookies  
	            clearExpired(new Date());  
	        }  
	    }  
	  
	    @Override  
	    public void addCookie(Cookie cookie) {  
	        if (omitNonPersistentCookies && !cookie.isPersistent())  
	            return;  
	        String name = cookie.getName() + cookie.getDomain();  
	  
	        // Save cookie into local store, or remove if expired  
	        if (!cookie.isExpired(new Date())) {  
	            cookies.put(name, cookie);  
	        } else {  
	            cookies.remove(name);  
	        }  
	  
	        // Save cookie into persistent store  
	        SharedPreferences.Editor prefsWriter = cookiePrefs.edit();  
	        prefsWriter.putString(COOKIE_NAME_STORE, TextUtils.join(",", cookies.keySet()));  
	        prefsWriter.putString(COOKIE_NAME_PREFIX + name, encodeCookie(new SerializableCookie(cookie)));  
	        prefsWriter.commit();  
	    }  
	  
	    @Override  
	    public void clear() {  
	        // Clear cookies from persistent store  
	        SharedPreferences.Editor prefsWriter = cookiePrefs.edit();  
	        for (String name : cookies.keySet()) {  
	            prefsWriter.remove(COOKIE_NAME_PREFIX + name);  
	        }  
	        prefsWriter.remove(COOKIE_NAME_STORE);  
	        prefsWriter.commit();  
	  
	        // Clear cookies from local store  
	        cookies.clear();  
	    }  
	  
	    @Override  
	    public boolean clearExpired(Date date) {  
	        boolean clearedAny = false;  
	        SharedPreferences.Editor prefsWriter = cookiePrefs.edit();  
	  
	        for (ConcurrentHashMap.Entry<String, Cookie> entry : cookies.entrySet()) {  
	            String name = entry.getKey();  
	            Cookie cookie = entry.getValue();  
	            if (cookie.isExpired(date)) {  
	                // Clear cookies from local store  
	                cookies.remove(name);  
	  
	                // Clear cookies from persistent store  
	                prefsWriter.remove(COOKIE_NAME_PREFIX + name);  
	  
	                // We've cleared at least one  
	                clearedAny = true;  
	            }  
	        }  
	  
	        // Update names in persistent store  
	        if (clearedAny) {  
	            prefsWriter.putString(COOKIE_NAME_STORE, TextUtils.join(",", cookies.keySet()));  
	        }  
	        prefsWriter.commit();  
	  
	        return clearedAny;  
	    }  
	  
	    @Override  
	    public List<Cookie> getCookies() {  
	        return new ArrayList<Cookie>(cookies.values());  
	    }  
	  
	    /** 
	     * Will make PersistentCookieStore instance ignore Cookies, which are non-persistent by 
	     * signature (`Cookie.isPersistent`) 
	     * 
	     * @param omitNonPersistentCookies true if non-persistent cookies should be omited 
	     */  
	    public void setOmitNonPersistentCookies(boolean omitNonPersistentCookies) {  
	        this.omitNonPersistentCookies = omitNonPersistentCookies;  
	    }  
	  
	    /** 
	     * Non-standard helper method, to delete cookie 
	     * 
	     * @param cookie cookie to be removed 
	     */  
	    public void deleteCookie(Cookie cookie) {  
	        String name = cookie.getName();  
	        cookies.remove(name);  
	        SharedPreferences.Editor prefsWriter = cookiePrefs.edit();  
	        prefsWriter.remove(COOKIE_NAME_PREFIX + name);  
	        prefsWriter.commit();  
	    }  
	  
	    /** 
	     * Serializes Cookie object into String 
	     * 
	     * @param cookie cookie to be encoded, can be null 
	     * @return cookie encoded as String 
	     */  
	    protected String encodeCookie(SerializableCookie cookie) {  
	        if (cookie == null)  
	            return null;  
	        ByteArrayOutputStream os = new ByteArrayOutputStream();  
	        try {  
	            ObjectOutputStream outputStream = new ObjectOutputStream(os);  
	            outputStream.writeObject(cookie);  
	        } catch (Exception e) {  
	            return null;  
	        }  
	  
	        return byteArrayToHexString(os.toByteArray());  
	    }  
	  
	    /** 
	     * Returns cookie decoded from cookie string 
	     * 
	     * @param cookieString string of cookie as returned from http request 
	     * @return decoded cookie or null if exception occured 
	     */  
	    protected Cookie decodeCookie(String cookieString) {  
	        byte[] bytes = hexStringToByteArray(cookieString);  
	        ByteArrayInputStream byteArrayInputStream = new ByteArrayInputStream(bytes);  
	        Cookie cookie = null;  
	        try {  
	            ObjectInputStream objectInputStream = new ObjectInputStream(byteArrayInputStream);  
	            cookie = ((SerializableCookie) objectInputStream.readObject()).getCookie();  
	        } catch (Exception exception) {  
	            Log.d(LOG_TAG, "decodeCookie failed", exception);  
	        }  
	  
	        return cookie;  
	    }  
	  
	    /** 
	     * Using some super basic byte array <-> hex conversions so we don't have to rely on any 
	     * large Base64 libraries. Can be overridden if you like! 
	     * 
	     * @param bytes byte array to be converted 
	     * @return string containing hex values 
	     */  
	    protected String byteArrayToHexString(byte[] bytes) {  
	        StringBuilder sb = new StringBuilder(bytes.length * 2);  
	        for (byte element : bytes) {  
	            int v = element & 0xff;  
	            if (v < 16) {  
	                sb.append('0');  
	            }  
	            sb.append(Integer.toHexString(v));  
	        }  
	        return sb.toString().toUpperCase(Locale.US);  
	    }  
	  
	    /** 
	     * Converts hex values from strings to byte arra 
	     * 
	     * @param hexString string of hex-encoded values 
	     * @return decoded byte array 
	     */  
	    protected byte[] hexStringToByteArray(String hexString) {  
	        int len = hexString.length();  
	        byte[] data = new byte[len / 2];  
	        for (int i = 0; i < len; i += 2) {  
	            data[i / 2] = (byte) ((Character.digit(hexString.charAt(i), 16) << 4) + Character.digit(hexString.charAt(i + 1), 16));  
	        }  
	        return data;  
	    }  

}
